// zhishi.js
// 获取app实例
const app = getApp();

Page({
  data: {
    showmsg: false,
    list: [1, 2, 3, 3, 3, 3, 3],
    totalHeaderHeightall: "",
    subjects: [], // 科目列表
    questions: [], // 题目列表
    selectedSubjectIds: [], // 选中的科目ID数组，支持多选
    selectedSubjectNames: '', // 已选科目名称字符串
    selectedSubjectsMap: {} // 对象映射，用于快速判断科目是否选中
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function () {
    this.setData({
      totalHeaderHeightall: app.globalData?.totalHeaderHeight
    });
    // 打印全局头部高度变量，方便调试
    console.log('全局头部总高度:', app.globalData?.totalHeaderHeight);

    // 加载科目列表
    this.loadSubjectList();
  },

  /**
   * 加载科目列表
   */
  loadSubjectList: function () {
    const that = this;
    // 从缓存获取userInfo中的school_id
    const userInfo = wx.getStorageSync('userInfo') || {};
    const schoolId = userInfo.school_id || 0;

    app.api.getSubjectList({ schoolId }).then(res => {
      console.log('获取科目列表成功:', res);
      // 正确使用res.data获取科目列表数据
      const subjects = res.data || [];
      that.setData({
        subjects: subjects
      });

      // 获取用户之前保存的科目
      that.loadUserSavedSubjects();
    }).catch(err => {
      console.error('获取科目列表失败:', err);
    });
  },

  /**
   * 从数据库加载用户之前保存的科目并回填选中状态
   */
  loadUserSavedSubjects: function () {
    // 显示加载提示
    wx.showLoading({
      title: '加载中...',
    });

    // 使用统一的API方法获取用户科目ID列表
    app.api.getUserSubjectIds().then(res => {
      console.log('从数据库获取用户科目ID成功:', res);
      // app.js的request方法已经处理了code检查，成功时直接返回res.data
      const savedSubjectIds = res.data || [];
      console.log('用户科目ID列表:', savedSubjectIds);

      if (savedSubjectIds.length === 0) {
        console.log('用户未保存过科目');
        wx.hideLoading();
        return;
      }

      // 创建选中状态的映射对象，确保所有ID都转换为字符串类型
      const selectedMap = {};
      // 将所有ID转换为字符串类型，确保类型一致性
      const stringSubjectIds = savedSubjectIds.map(id => String(id));
      stringSubjectIds.forEach(id => {
        selectedMap[id] = true;
      });

      // 更新选中状态，确保selectedSubjectIds也使用字符串类型
      this.setData({
        selectedSubjectIds: stringSubjectIds,
        selectedSubjectsMap: selectedMap
      });

      // 确保科目列表已加载后再更新已选科目名称
      if (this.data.subjects && this.data.subjects.length > 0) {
        this.updateSelectedSubjectNames();
        console.log('科目选择状态已回填，已选科目名称已更新');
      } else {
        console.log('科目列表尚未加载，稍后更新已选科目名称');
        // 等待科目列表加载完成后再更新
        const timer = setInterval(() => {
          if (this.data.subjects && this.data.subjects.length > 0) {
            clearInterval(timer);
            this.updateSelectedSubjectNames();
            console.log('延迟更新已选科目名称');
          }
        }, 100);
        // 设置超时保护
        setTimeout(() => clearInterval(timer), 5000);
      }
    }).catch(err => {
      console.error('获取用户科目ID失败:', err.message || '未知错误');
    }).finally(() => {
      wx.hideLoading();
    });
  },

  /**
   * 切换科目选择状态
   */
  toggleSubjectSelection: function (e) {
    // 确保获取的是字符串类型ID
    let subjectId = String(e.currentTarget.dataset.id);

    console.log('切换科目选择状态，当前科目ID:', subjectId);

    const { selectedSubjectIds, selectedSubjectsMap, subjects } = this.data;
    // 检查科目是否已选中
    const isSelected = !!selectedSubjectsMap[subjectId];

    // 创建新的选中ID数组和映射对象
    let newSelectedIds = [...selectedSubjectIds];
    let newSelectedMap = { ...selectedSubjectsMap };

    if (isSelected) {
      // 已选中，取消选择
      // 重要：确保使用相同的类型进行比较
      newSelectedIds = newSelectedIds.filter(id => String(id) !== subjectId);
      // 同时删除映射中的两种可能的键类型
      delete newSelectedMap[subjectId];
      delete newSelectedMap[parseInt(subjectId)];
    } else {
      // 找到当前要选择的科目的school_id
      const currentSubject = subjects.find(subject => String(subject.id) === subjectId);
      if (!currentSubject) {
        console.error('未找到对应的科目信息');
        return;
      }

      const currentSchoolId = currentSubject.school_id;

      // 计算当前学校已选中的科目数量
      const currentSchoolSelectedCount = newSelectedIds.filter(id => {
        const subject = subjects.find(s => String(s.id) === id);
        return subject && subject.school_id === currentSchoolId;
      }).length;

      // 未选中，检查是否已达到最大选择数量（按学校限制5个）
      if (currentSchoolSelectedCount >= 5) {
        this.setData({
          showmsg: true,
          massges: "最多选择5个科目",
        });
        setTimeout(() => {
          this.setData({
            showmsg: false,
            massges: "最多选择5个科目",
          });
        }, 1000);
        return;
      }
      // 添加选择
      newSelectedIds.push(subjectId);
      newSelectedMap[subjectId] = true;
    }

    console.log('更新后的选中科目ID数组:', newSelectedIds);
    console.log('更新后的选中映射:', newSelectedMap);

    // 强制更新所有相关数据
    this.setData({
      selectedSubjectIds: newSelectedIds,
      selectedSubjectsMap: newSelectedMap
    });

    // 立即更新已选科目名称显示
    this.updateSelectedSubjectNames();
  },

  /**
   * 更新已选科目名称显示
   */
  updateSelectedSubjectNames: function () {
    const { selectedSubjectIds, subjects } = this.data;
    console.log('更新已选科目名称，选中的ID:', selectedSubjectIds);
    console.log('科目列表:', subjects);

    if (selectedSubjectIds.length === 0) {
      this.setData({ selectedSubjectNames: '' });
      console.log('未选择科目，设置为空字符串');
      return;
    }

    // 确保subjects是数组
    if (!Array.isArray(subjects) || subjects.length === 0) {
      console.log('科目列表为空或无效');
      return;
    }

    // 创建科目ID到名称的映射，处理不同类型的ID比较
    const subjectMap = {};
    subjects.forEach(subject => {
      // 存储两种类型的键，确保查找准确
      subjectMap[subject.id] = subject.name;
      subjectMap[String(subject.id)] = subject.name;
    });

    console.log('创建的科目映射:', subjectMap);

    // 遍历选中的ID，查找对应的科目名称
    const foundNames = [];
    selectedSubjectIds.forEach(id => {
      const name = subjectMap[id] || subjectMap[String(id)];
      if (name) {
        foundNames.push(name);
      }
    });

    console.log('找到的科目名称:', foundNames);

    // 生成科目名称字符串
    let subjectNames = '';
    if (foundNames.length > 0) {
      subjectNames = foundNames.join('、');
    } else {
      // 当没有找到任何匹配的科目名称时，才使用ID显示
      subjectNames = selectedSubjectIds.join('、');
    }

    console.log('生成的科目名称字符串:', subjectNames);

    // 更新已选科目名称
    this.setData({
      selectedSubjectNames: subjectNames
    });
  },

  /**
   * 确认选择
   */
  confirmSelection: function () {
    const { selectedSubjectIds } = this.data;

    if (selectedSubjectIds.length === 0) {
      wx.showToast({
        title: '请至少选择一个科目',
        icon: 'none'
      });
      return;
    }

    // 显示加载提示
    wx.showLoading({
      title: '保存中...',
    });

    // 调用API保存用户选择的科目
    const app = getApp();
    wx.request({
      url: app.globalData.baseUrl + '/frontend/saveUserSubjects',
      method: 'POST',
      data: {
        subjectIds: selectedSubjectIds
      },
      header: {
        'content-type': 'application/json',
        'token': wx.getStorageSync('userToken') || ''
      },
      success: (res) => {
        if (res.data && res.data.code === 200) {
          // 已通过API保存到数据库，无需保存到本地存储

          // 直接跳转到知识点页面，不再通过URL传递科目数据
          wx.redirectTo({
            url: '../index/index'
          });
        } else {
          wx.showToast({
            title: res.data?.msg || '保存失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('保存科目失败:', err);
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  }
});
